import { defineStore } from 'pinia'
import { ref, computed } from 'vue'
import { cartAPI } from '@/api/cart'
import { useUserStore } from '@/stores/user'
import { ElMessage } from 'element-plus'

export const useCartStore = defineStore('cart', () => {
  // 购物车商品列表
  const cartItems = ref([])

  // 立即购买商品列表（临时存储）
  const buyNowItems = ref([])

  // 是否为立即购买模式
  const isBuyNowMode = ref(false)

  // 购物车商品总数
  const cartCount = computed(() => {
    return cartItems.value.reduce((total, item) => total + item.quantity, 0)
  })

  // 购物车商品总价
  const cartTotal = computed(() => {
    return cartItems.value.reduce((total, item) => total + item.price * item.quantity, 0).toFixed(2)
  })

  // 立即购买商品总价
  const buyNowTotal = computed(() => {
    return buyNowItems.value.reduce((total, item) => total + item.price * item.quantity, 0).toFixed(2)
  })

  // 当前结算商品列表（根据模式返回不同的商品列表）
  const checkoutItems = computed(() => {
    return isBuyNowMode.value ? buyNowItems.value : cartItems.value
  })

  // 当前结算总价
  const checkoutTotal = computed(() => {
    return isBuyNowMode.value ? buyNowTotal.value : cartTotal.value
  })

  /**
   * 添加商品到购物车
   * @param {Object} product - 要添加的商品信息
   * @param {number} quantity - 添加的数量，默认为1
   */
  async function addToCart(product, quantity = 1) {
    const userStore = useUserStore()

    try {
      if (userStore.isLoggedIn) {
        // 用户已登录，调用后端API
        await cartAPI.addToCart(product.id, quantity)
        // 重新加载购物车数据
        await loadCartFromServer()
        ElMessage.success(`已将《${product.title}》加入购物车`)
      } else {
        // 用户未登录，使用本地存储
        const existingItem = cartItems.value.find(item => item.id === product.id)

        if (existingItem) {
          // 如果商品已存在，增加数量
          existingItem.quantity += quantity
        } else {
          // 如果商品不存在，添加新商品
          cartItems.value.push({
            id: product.id,
            title: product.title,
            price: parseFloat(product.price),
            cover: product.cover,
            quantity: quantity,
            author: product.author
          })
        }

        saveCartToLocalStorage()
        ElMessage.success(`已将《${product.title}》加入购物车`)
      }
    } catch (error) {
      console.error('添加到购物车失败：', error)

      // 获取错误信息 - axios拦截器已经处理了错误，直接使用error.message
      const errorMessage = error.message || '添加到购物车失败'

      ElMessage.error(errorMessage)
    }
  }

  /**
   * 从购物车移除商品
   * @param {number} productId - 要移除的商品ID
   */
  async function removeFromCart(productId) {
    const userStore = useUserStore()

    try {
      if (userStore.isLoggedIn) {
        // 用户已登录，调用后端API
        await cartAPI.removeFromCart(productId)
        // 重新加载购物车数据
        await loadCartFromServer()
      } else {
        // 用户未登录，使用本地存储
        const index = cartItems.value.findIndex(item => item.id === productId)
        if (index !== -1) {
          cartItems.value.splice(index, 1)
          saveCartToLocalStorage()
        }
      }
    } catch (error) {
      console.error('删除商品失败：', error)
      ElMessage.error(error.message || '删除商品失败')
    }
  }

  /**
   * 更新购物车中商品的数量
   * @param {number} productId - 商品ID
   * @param {number} quantity - 新的数量
   */
  async function updateQuantity(productId, quantity) {
    const userStore = useUserStore()

    try {
      if (userStore.isLoggedIn) {
        // 用户已登录，调用后端API
        await cartAPI.updateCartQuantity(productId, quantity)
        // 重新加载购物车数据
        await loadCartFromServer()
      } else {
        // 用户未登录，使用本地存储
        const item = cartItems.value.find(item => item.id === productId)
        if (item) {
          item.quantity = quantity
          saveCartToLocalStorage()
        }
      }
    } catch (error) {
      console.error('更新数量失败：', error)
      ElMessage.error(error.message || '更新数量失败')
    }
  }

  /**
   * 清空购物车
   */
  async function clearCart() {
    const userStore = useUserStore()

    try {
      if (userStore.isLoggedIn) {
        // 用户已登录，调用后端API
        await cartAPI.clearCart()
        // 清空本地数据
        cartItems.value = []
      } else {
        // 用户未登录，清空本地存储
        cartItems.value = []
        saveCartToLocalStorage()
      }
    } catch (error) {
      console.error('清空购物车失败：', error)
      ElMessage.error(error.message || '清空购物车失败')
    }
  }

  /**
   * 设置立即购买商品
   * @param {Object} product - 要立即购买的商品信息
   * @param {number} quantity - 购买数量，默认为1
   */
  function setBuyNowItem(product, quantity = 1) {
    buyNowItems.value = [{
      id: product.id,
      title: product.title,
      price: parseFloat(product.price),
      cover: product.cover || product.thumbnails?.[0], // 支持不同的封面字段
      quantity: quantity,
      author: product.author
    }]
    isBuyNowMode.value = true
  }

  /**
   * 清空立即购买商品并退出立即购买模式
   */
  function clearBuyNowItems() {
    buyNowItems.value = []
    isBuyNowMode.value = false
  }

  /**
   * 更新立即购买商品的数量
   * @param {number} productId - 商品ID
   * @param {number} quantity - 新的数量
   */
  function updateBuyNowQuantity(productId, quantity) {
    const item = buyNowItems.value.find(item => item.id === productId)
    if (item) {
      item.quantity = quantity
    }
  }

  /**
   * 将购物车保存到本地存储
   */
  function saveCartToLocalStorage() {
    localStorage.setItem('cart', JSON.stringify(cartItems.value))
  }

  /**
   * 从服务器加载购物车数据
   */
  async function loadCartFromServer() {
    try {
      const response = await cartAPI.getUserCart()
      console.log('购物车数据响应：', response)

      // axios拦截器已经处理了响应，直接使用response.data
      cartItems.value = response.data || []

      // 调试：打印每个商品的封面信息
      cartItems.value.forEach(item => {
        console.log(`商品 ${item.title} 的封面：`, item.cover)
      })
    } catch (error) {
      console.error('从服务器加载购物车失败：', error)
      // 如果服务器加载失败，尝试从本地存储加载
      loadCartFromLocalStorage()
    }
  }

  /**
   * 从本地存储加载购物车
   */
  function loadCartFromLocalStorage() {
    const savedCart = localStorage.getItem('cart')
    if (savedCart) {
      cartItems.value = JSON.parse(savedCart)
    }
  }

  /**
   * 同步本地购物车数据到服务器（用于登录时）
   */
  async function syncCartToServer() {
    const userStore = useUserStore()

    if (!userStore.isLoggedIn || cartItems.value.length === 0) {
      return
    }

    try {
      // 将本地购物车数据同步到服务器
      await cartAPI.syncCartFromLocal(cartItems.value)
      // 同步完成后，从服务器重新加载数据
      await loadCartFromServer()
      // 清空本地存储
      localStorage.removeItem('cart')
    } catch (error) {
      console.error('同步购物车到服务器失败：', error)
    }
  }

  /**
   * 初始化购物车数据
   */
  async function initializeCart() {
    const userStore = useUserStore()

    console.log('初始化购物车 - 用户登录状态：', userStore.isLoggedIn)
    console.log('初始化购物车 - 用户信息：', userStore.userInfo)
    console.log('初始化购物车 - token：', userStore.token)

    if (userStore.isLoggedIn) {
      console.log('用户已登录，从服务器加载购物车数据')
      // 用户已登录，从服务器加载数据
      await loadCartFromServer()
      // 如果本地有数据，同步到服务器
      const localCart = localStorage.getItem('cart')
      if (localCart) {
        const localCartItems = JSON.parse(localCart)
        if (localCartItems.length > 0) {
          await syncCartToServer()
        }
      }
    } else {
      console.log('用户未登录，从本地存储加载购物车数据')
      // 用户未登录，从本地存储加载
      loadCartFromLocalStorage()
    }
  }

  // 初始化购物车
  initializeCart()

  return {
    cartItems,
    cartCount,
    cartTotal,
    buyNowItems,
    buyNowTotal,
    isBuyNowMode,
    checkoutItems,
    checkoutTotal,
    addToCart,
    removeFromCart,
    updateQuantity,
    clearCart,
    setBuyNowItem,
    clearBuyNowItems,
    updateBuyNowQuantity,
    loadCartFromServer,
    syncCartToServer,
    initializeCart
  }
})